`:top

`!Parameter`! – (deutsch) auch `!Übergabewerte`! genannt – sind in der `F33f`_`[Informatik`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Informatik]`_`f `F33f`_`[Variablen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Variable_(Programmierung)]`_`f, durch die ein `F33f`_`[Computerprogramm`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerprogramm]`_`f (oft ein `F33f`_`[Unterprogramm`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Unterprogramm]`_`f) auf die Verarbeitung bestimmter Werte „eingestellt“ werden kann. Parameter sind also programmextern gesetzte `*Einflussfaktoren`*; sie werden insbesondere beim Aufruf von Unterprogrammen verwendet, um diesen ‚mitzuteilen‘, welche Daten/Werte sie verarbeiten sollen und ggf. wie.

Durch Parametrisierung können Programme in ihrer Anwendung flexibilisiert werden, ohne dass das Programm dazu neu erstellt oder geändert werden muss. Welche Sachverhalte eingestellt werden können, muss bei der Erstellung des Programms (als `F33f`_`[Anforderung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Anforderung_(Informatik)]`_`f) festgelegt werden. Parameter können z. B. bestimmte Grenzwerte/Auswahlbedingungen (für Beträge, ein Datum oder ähnliches) oder zu verwendende Texte sein oder auch das „Was“ und das „Wie“ der Verarbeitung steuern (z. B. Prüfung X vornehmen – ja/nein).

Begrifflich wird unterschieden zwischen „`F33f`_`[formalen Parametern`#formale-parameter]`_`f“ (= als Teil der Funktionsdefinition im Programmcode; Bsp.: `B100`F9d9<Funktionsname>( <Par1>, <Par2>, ..) `f`b) und „`F33f`_`[tatsächlichen Parametern`#tats-chliche-parameter-oder-argumente]`_`f“, auch „Argumente“ genannt (= der jeweilige Wert für `B100`F9d9Par1`f`b oder `B100`F9d9Par2`f`b bei einzelnen Funktionsaufrufen).

Wird beim Aufruf des (Unter-)Programms nicht für jeden Parameter ein Argument übergeben, kann dieses eine beim Erstellen des Programms festgelegte `F33f`_`[Standardannahme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Standardannahme]`_`f verwenden oder (je nach Implementierung) die Verarbeitung wegen fehlender Parameter abbrechen.

>>Contents

• `F0af`_`[Zweck von Parametern`#zweck-von-parametern]`_`f

• `F0af`_`[Unterschiedliche Parameter-Begriffe`#unterschiedliche-parameter-begriffe]`_`f

• `F0af`_`[Beispiele für Parameter`#beispiele-f-r-parameter]`_`f

• `F0af`_`[Medien zur Parameterübergabe`#medien-zur-parameter-bergabe]`_`f

• `F0af`_`[Parameter bei Unterprogrammen`#parameter-bei-unterprogrammen]`_`f

• `F0af`_`[Übergabe der Parameter/Argumente`#bergabe-der-parameter-argumente]`_`f

• `F0af`_`[Übergabe über den Stack`#bergabe-ber-den-stack]`_`f

• `F0af`_`[Werte oder Referenzen/Zeiger als Parameter`#werte-oder-referenzen-zeiger-als-parameter]`_`f

• `F0af`_`[Rückschreiben über referenzierte Daten`#r-ckschreiben-ber-referenzierte-daten]`_`f

• `F0af`_`[Umsetzung auf Maschinenebene`#umsetzung-auf-maschinenebene]`_`f

• `F0af`_`[Definition und technische Anwendung von Unterprogramm-Parametern`#definition-und-technische-anwendung-von-unterprogramm-parametern]`_`f

• `F0af`_`[Formale Parameter`#formale-parameter]`_`f

• `F0af`_`[Tatsächliche Parameter oder Argumente`#tats-chliche-parameter-oder-argumente]`_`f

• `F0af`_`[Type-Hinting`#type-hinting]`_`f

• `F0af`_`[Ersetzen der formalen durch tatsächliche Parameter`#ersetzen-der-formalen-durch-tats-chliche-parameter]`_`f

• `F0af`_`[Beispiel für verschiedene Parameterübergaben`#beispiel-f-r-verschiedene-parameter-bergaben]`_`f

• `F0af`_`[Befehlszeilenparameter`#befehlszeilenparameter]`_`f

• `F0af`_`[Siehe auch`#siehe-auch]`_`f

• `F0af`_`[Einzelnachweise`#einzelnachweise]`_`f

-─

>>Zweck von Parametern

• Parametrisierung ist ein Aspekt der `F33f`_`[Softwarearchitektur`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Softwarearchitektur]`_`f: So implementierte `F33f`_`[Software`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Software]`_`f kann den `*Qualitätskriterien für Software nach `F33f`_`[ISO/IEC 9126`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ISO/IEC_9126]`_`f`* vor allem in den Punkten `*Anpassbarkeit`* und `*Modifizierbarkeit`* entsprechen, unterstützt aber auch die Anforderungen `*Austauschbarkeit`*, `*Bedienbarkeit`* und andere.

• Durch Parametrisierung können Programmänderungen für im Voraus erwartbare Situationen vermieden und damit Aufwand und Fehlerrisiken (durch Programmänderungen) minimiert werden.

• Für Programmeinsätze in vielen unterschiedlichen Umgebungen (`F33f`_`[Mandantenfähigkeit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mandantenfähigkeit]`_`f) ist die Parametrisierung unabdingbare Voraussetzung. Vor allem bei Systemprogrammen wird sie deshalb in der Regel sehr umfassend praktiziert (mindestens über `F33f`_`[Konfigurationsparameter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Konfiguration_(Computer)]`_`f).

• In der `F33f`_`[modularen Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Modulare_Programmierung]`_`f sind die `*Schnittstellen`* zwischen den einzelnen Modulen implementierungsimmanente Parameter. Sie sind Bestandteile der `F33f`_`[Signatur`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Signatur_(Programmierung)]`_`f von `F33f`_`[Funktionen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktion_(Programmierung)]`_`f, `F33f`_`[Methoden`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Methode_(Programmierung)]`_`f und `F33f`_`[Prozeduren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Prozedur_(Programmierung)]`_`f und somit ein wesentliches Kommunikationsmedium zwischen aufrufendem Programm und aufgerufenem `F33f`_`[Unterprogramm`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Unterprogramm]`_`f, Informationen können in beide Richtungen fließen.

• Im weiteren Sinn sind auch `F33f`_`[Makros`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Makro]`_`f Subroutinen: Für sie legt der Programmierer im `F33f`_`[Quelltext`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Quelltext]`_`f Parameter fest und bestimmt damit die Verarbeitungsdetails für das Makro.

Parameter sind aus Sicht des `F33f`_`[Systembegriffs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Systemtheorie]`_`f `*Inputdaten`*; sie unterscheiden sich jedoch von normalen Eingabedaten z. B. wie folgt:

• Parameterdaten gehören nicht zum eigentlichen Verarbeitungszweck des Programms, sondern sie sollen – soweit dies bei der Implementierung berücksichtigt wurde – das Programm auf individuelle Werte/Informationen und/oder mögliche Varianten der Verarbeitung einstellen.

• Parameterdaten sind in der Regel eindimensional, d. h., es gibt keine Objektmengen (wie z. B. in einer Kunden- oder Produktdatei), sondern meist nur die zu einer konkreten Situation gehörenden Angaben, oft nur in Form eines einzelnen `F33f`_`[Datenfeldes`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenfeld]`_`f.

• Sie werden vom Programm in der Regel nicht einfach gelesen wie andere `F33f`_`[Dateien`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datei]`_`f, sondern häufig über spezielle Mechanismen (des `F33f`_`[Betriebssystems`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Betriebssystem]`_`f oder der `F33f`_`[Programmiersprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f) interpretiert, insbesondere bei Verwendung als Unterprogramm-Parameter.

• Außer bei Unterprogrammen werden sie meist durch die für den technischen Ablauf des Programms verantwortlichen `F33f`_`[Benutzer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Benutzer]`_`f, `F33f`_`[Nutzer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Nutzung_(Technik)]`_`f oder Betreiber von Computern vorgegeben, z. B. Mitarbeiter des Rechenzentrums, und bleiben in diesen Fällen oft über längere Zeit unverändert.

>>Unterschiedliche Parameter-Begriffe

Parameter werden in unterschiedlichen Funktionen in der Informatik verwendet:

• als Installationsparameter bei der Installation einer Software

• als `F33f`_`[Konfigurationsparameter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Konfiguration_(Computer)]`_`f, die das Verhalten der Software steuern

• als Laufzeitparameter, um die Software zur Laufzeit beeinflussen zu können.

• als Schnittstelle zwischen aufrufenden Programmen und aufgerufenen Unterprogrammen; siehe unten.

Bei Verwendung mehrerer Parameter ist es wichtig, die einzelnen Parameter identifizieren und unterscheiden zu können. Hierzu gibt es zwei Erkennungsmethoden:

`!Positionsparameter`!

werden bei der Übergabe anhand ihrer Position zugewiesen. Beispiel: Der dritte Parameter ist die Startzeit. Wenn die Parameterwerte keine feste Länge haben, müssen Positionsparameter durch ein `F33f`_`[Trennzeichen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Trennzeichen]`_`f getrennt werden. Als Trennzeichen wird z. B. das `F33f`_`[Semikolon`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Semikolon]`_`f (siehe `F33f`_`[CSV-Datei`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=CSV-Datei]`_`f) oder der `F33f`_`[senkrechte Strich`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Senkrechter_Strich]`_`f verwendet. Nicht vorzugebende Argumente werden hierbei in der Regel nur durch ihr Trennzeichen gekennzeichnet, was zu Stringfolgen wie `B100`F9d9300;ABC;;;XYZ`f`b (dritter und vierter Parameter nicht verwendet) führt.

`:schl-c3-bcsselwortparameter`a`:schl-sselwortparameter`a

`!Schlüsselwortparameter`!

werden bei der Übergabe mit einem eindeutigen `F33f`_`[Schlüsselwort`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schlüsselwort_(Programmierung)]`_`f gekennzeichnet und sind somit unabhängig von ihrer Position identifizierbar. Beispiel: `B100`F9d9startzeit=13:30`f`b. Auch bei Schlüsselwortparametern ist ein Trennzeichen erforderlich.

Schlüsselwortparameter zeichnen sich gegenüber Positionsparametern meist dadurch aus, dass sie auch weggelassen werden können.

Ob leere Parameter erlaubt sind und wie dies zu behandeln ist, z. B. leere `F33f`_`[Zeichenkette`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zeichenkette]`_`f oder `F33f`_`[Standardannahme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Standardannahme]`_`f (englisch `*default argument`*), ist durch das Programm zu behandeln. Ebenso muss für beide Varianten festgelegt/vereinbart sein, in welchem `*Format`* sie anzugeben sind; im Beispiel: „hh:mm“, jeweils 2 Stellen, getrennt durch einen Doppelpunkt.

Weiterhin lassen sich Parameter `*unterscheiden`* nach:

`!Quelle der Parameter`!

`*Intern`* = von Programm zu (Unter-)Programm wirksam; `*Extern`* = von außen, z. B. durch Benutzer gesetzte Parameter

`!Stabilität/Änderungshäufigkeit`!

Wird der Parameter häufig oder `*fast immer neu`* gesetzt oder wird er `*selten verändert`*?

`!Art/Typ der Parameter`!

`*Variablen`* wie Betragsfelder (z. B. Grenzwerte), Zeitangaben (Tagesdatum), Textkonstanten und so weiter oder `*funktional wirkende Anweisungen`* wie „J/N“ o. ä. (für ‚nur fehlerhafte Daten auflisten‘, ‚nur protokollieren, nicht speichern‘)

`!Richtung des Informationsflusses`!

`*Aufrufparameter`* (in Richtung Programm/Unterprogramm) oder `*Rückgabeparameter`* (in Richtung aufrufendes Programm; nur bei Unterprogrammen); auch `*bidirektional`* ist möglich (Aufruf/Rückgabe)

>>Beispiele für Parameter

• Mehrwertsteuersätze in Prozent (bei betriebswirtschaftlichen Anwendungen)

• Sollen in Listen nur Summen- oder auch Einzelzeilen ausgegeben werden? (steuert den Detaillierungsgrad von Benutzermedien)

• Bezeichnung des Software-Eigentümers (i. Z. mit `F33f`_`[Mandantenfähigkeit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mandantenfähigkeit]`_`f, in Formularköpfen sichtbar)

• Kreditbetrag, Zinssatz, Tilgungsbetrag, Tilgungsperiode (zur Berechnung eines `F33f`_`[Tilgungsplans`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Tilgungsplan]`_`f)

• `F33f`_`[Kontonummer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kontonummer]`_`f als Aufrufparameter an das Unterprogramm 'Prüfziffernberechnung’, `F33f`_`[Prüfziffer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Prüfziffer]`_`f als Rückgabewert

In weitestem Sinn sind auch Computerbefehle (in allen `F33f`_`[Programmiersprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f und auch in `F33f`_`[Maschinensprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Maschinensprache]`_`f) Parameter: Sie enthalten einen Funktionscode plus Adressen, Längen und so weiter für die zu verarbeitenden Daten. Die Angaben werden vom `F33f`_`[Steuerwerk`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Steuerwerk]`_`f des Computers interpretiert und decodiert und entsprechend ausgeführt.

`!Ein konkretes Beispiel für die Anwendung von Parametern:`!

Als Teil einer Anwendung zur Verwaltung von Rechnungen soll ein Programm entstehen, das für die Benutzer Rechnungen in einer Liste ausgibt. Als fachliche Vorgabe wurde festgelegt, dass in dieser Liste alle Rechnungen ausgewiesen werden, die noch nicht bezahlt sind und die älter als 1 Monat sind, berechnet zum Zeitpunkt des Programmlaufs.

• Ohne Parametrisierung würde das Programm also verarbeiten:

Lese Rechnungen; verarbeite nur Rechnungen mit Status = „offen“ und Rechnungsdatum < (heute ./. 1 Monat)

• Eine identische Lösung mit Parametern könnte hierzu die Parameter „Rechnungsdatum älter als“, „offen_JN“ vorsehen.

Hierbei müsste das Programm die Parameter nach dem Start prüfen und gegebenenfalls zur Verwendung vorbearbeiten. In der eigentlichen Verarbeitung würden dann keine Konstanten oder fix codierten Befehle (wie vor) verwendet, sondern die gesetzten Parameterwerte.

• Für die Benutzer ergäben sich damit folgende weiter gehenden Möglichkeiten:

Das Alter der Rechnung könnte variabel bestimmt werden; die Liste könnte gegebenenfalls auch erledigte Rechnungen oder alle Rechnungen unabhängig vom Status zeigen.

• Weiter gehend könnte z. B. der Parameter „ab Betrag = X“ vorgesehen werden oder auch die Festlegung, ob nur Rechnungen mit höheren oder nur Rechnungen mit niedrigeren Rechnungsbeträgen als X oder alle Rechnungen unabhängig von der Betragshöhe aufzulisten sind. Rechnungen mit Bagatellbeträgen könnten so z. B. ausgeschlossen oder in einer getrennten Liste angefordert werden.

• Je nach verwendetem Datenbanksystem können bestimmte Parameter bereits in das Lesekommando für die Rechnungsdaten eingestellt werden, wodurch das `F33f`_`[DBMS`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=DBMS]`_`f nur entsprechende Rechnungen bereitstellt. Alternativ müsste das Programm die Auswahl nach dem Lesen selbst vornehmen.

>>Medien zur Parameterübergabe

• Ist das Programm ein `*`F33f`_`[Unterprogramm`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Unterprogramm]`_`f`*, so werden der (oder auch mehrere Parameter) bei dessen Definition formal festgelegt (formaler Parameter) und (vom Hauptprogramm) beim Aufruf des Unterprogramms für jeweils genau einen Aufruf auf einen konkreten Wert gesetzt (tatsächlicher Parameter).

• `*`F33f`_`[Kommandozeilenparameter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kommandozeilenparameter]`_`f`* werden im Aufrufkommando, meist im Anschluss an den Code für die auszuführende Funktion, übergeben. Beispiel: RENAME <alter Dateiname, neuer Dateiname>. In diese Kategorie gehören auch die Parameter, die bei Programmaufrufen über eine `F33f`_`[Job-Control-Sprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Job_Control_Language]`_`f (bei `F33f`_`[Großrechnerprogrammen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Großrechner]`_`f z. B. OPC) in den Anweisungen eingestellt werden, z. B. das Tagesdatum.

• Parameter können auch in speziellen `*Parameterdateien`* enthalten sein. Ihr Inhalt wird in diesem Fall von einer Steuerungskomponente des Programms zum Ausführungszeitpunkt, gegebenenfalls bei Programmstart interpretiert. Beispiele hierfür sind Einträge in sog. `F33f`_`[Registrierungsdatenbanken`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Registrierungsdatenbank]`_`f (in der Regel für `F33f`_`[Dienstprogramme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dienstprogramm]`_`f benutzt), aber auch in betrieblichen bzw. aufgabenspezifischen `F33f`_`[Datenbanken`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenbank]`_`f, `F33f`_`[Dateien`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datei]`_`f oder Tabellenverwaltungssystemen.

Je nach Medium werden Parameter mit unterschiedlichen Verfahren `*erfasst`*, externe Parameter häufig mithilfe von Standard- oder individuellen `F33f`_`[Editoren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Editor_(Software)]`_`f. Parameter für `*Dialogprogramme`* können, wenn dies im Programm vorgesehen ist, vom Benutzer direkt über `F33f`_`[Bildschirm`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bildschirm]`_`f und `F33f`_`[Tastatur`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Tastatur]`_`f eingegeben werden.

>>Parameter bei Unterprogrammen

Eine essentielle Bedeutung haben Parameter in Verbindung mit der Verwendung von Unterprogrammen. Diese verarbeiten Daten und liefern Werte zurück, die meist zu den sie aufrufenden Programmen gehören. Um einem Unterprogramm (das die Daten des rufenden Programms grundsätzlich nicht 'kennt') die Teilmenge an Daten mitzuteilen, die es verarbeiten muss, verwendet man beim Aufruf des Unterprogramms bestimmte Techniken, die in höheren Programmiersprachen durch eine sogenannte `*`!formale Parameterliste`!`* abgebildet werden. Dieser Ausdruck wurde bereits in den 1960er Jahren für die damals als Lehrbeispiel entstandene Sprache `F33f`_`[ALGOL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ALGOL]`_`f benutzt und ist noch heute üblich. Die Begriffe `*Parameter`* oder `*Argument`* werden in diesem Kontext oft synonym verwendet, wobei sich „Parameter“ genau genommen auf die Funktionsdefinition bezieht, „Argument“ hingegen auf den tatsächlichen Aufruf. Den Unterprogrammen wird beim Aufruf über die `*tatsächliche Parameterliste`* (genauer: Argumentliste) bestimmte Werte übergeben, mit denen sie arbeiten können. Die Unterprogramme liefern in der Regel `*Rückgabewerte`* zurück.

Alle genannten `*Werte`* können auch `*`F33f`_`[Referenzen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Referenz_(Programmierung)]`_`f`*, `*Zeiger`* oder `*Adressen`* auf Speicherbereiche sein. Die genannten Begriffe sind ebenfalls synonym. Im C++-Jargon wird allerdings oft streng zwischen `*Referenz`* und `*Zeiger`* unterschieden, mit `*Referenz`* wird die mit `B100`F9d9Type&`f`b deklarierte Variante bezeichnet, Zeiger dagegen mit `B100`F9d9Type*`f`b. Der Unterschied besteht darin, das eine Referenz im Gegensatz zum Zeiger nicht uninitialisiert oder leer sein darf. Das bedeutet, bei Verwendung einer Referenz muss immer ein gültiges Objekt des entsprechenden Typs übergeben werden. Referenzen auf Grunddatentypen sind ebenfalls erlaubt (z. B. `B100`F9d9int&`f`b).

>>>Übergabe der Parameter/Argumente

Abhängig von der `F33f`_`[Rechnerarchitektur`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rechnerarchitektur]`_`f und der Programmiersprache werden zur Übergabe von Parametern vom aufrufenden an den aufzurufenden Softwareteil unterschiedliche Verfahren und Konventionen benutzt. Zum Beispiel können die Parameter über `F33f`_`[Register`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Register_(Computer)]`_`f übergeben werden, wobei durch Konventionen festgelegte Register(nummern) auf eine Adressliste zeigen (die die Adressen der Parameter/Argumente enthält), ein Register enthält die Einsprungadresse im Unterprogramm, ein anderes die Rücksprüngadresse. Details siehe `F33f`_`[Objektmodule bei Großrechnern`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Modul_(Software)]`_`f.

>>>Übergabe über den Stack

In anderen `F33f`_`[Systemumgebungen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Systemumgebung]`_`f wird dazu einen `F33f`_`[Stack`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stapelspeicher]`_`f-Mechanismus verwendet. In diesen Fällen ist zum Verständnis der Funktionsweise von Unterprogrammen folgendes Basiswissen notwendig:

Grundsätzlich ist der Speicher von Prozessoren unterteilt in

• Programmspeicher: Dort steht der Maschinencode, der als Befehle abgearbeitet wird.

• `F33f`_`[Dynamischer Speicher`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dynamischer_Speicher]`_`f (`*Heap`*): Dort sind Daten abgespeichert.

• `F33f`_`[Stapelspeicher`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stapelspeicher]`_`f (`*Stack`*, `F33f`_`[Aufrufstapel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Aufrufstapel]`_`f): Das ist ein besonderer `F33f`_`[Speicherbereich`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Speicherbereich]`_`f, dessen Verwendung insbesondere bei Unterprogrammen eine Rolle spielt.

Jeder `F33f`_`[Thread`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Thread_(Informatik)]`_`f hat seinen eigenen Stapelspeicher. In diesem werden gespeichert:

• Die Rücksprungadressen für die Fortsetzung der Programmbearbeitung nach Abarbeitung des Unterprogramms

• Die tatsächlichen Parameter

• Alle Daten, die lokal in einer Prozedur vereinbart werden

• Rückgabewerte

Der Stack wird bei der Programmabarbeitung im Maschinencode über ein spezielles Adressregister adressiert, den `*Stackpointer`* oder `F33f`_`[Stapelzeiger`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stapelzeiger]`_`f. Dieser adressiert immer das untere Ende des als Stack benutzen Speicherbereiches. Hinzu kommt zumeist ein `*Basepointer`*, der eine Basisadresse der Variablen und tatsächlichen Parameter innerhalb des Stacks adressiert. Der Begriff `*Stack`* ist im Deutschen als „Stapel“ übersetzbar, auch der Begriff „Kellerspeicher“ wird benutzt. Im Stack werden Informationen gestapelt und nach dem Prinzip `F33f`_`[Last In – First Out`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Last_In_–_First_Out]`_`f (LIFO) gespeichert und wieder ausgelesen. Allerdings kann der Zugriff auch auf beliebige Adressen innerhalb des Stacks erfolgen.

Die Parameterübergabe erfolgt über den Stack. Jeder tatsächliche Parameter wird in der Reihenfolge der Abarbeitung, üblicherweise von links nach rechts (gemäß einer strikt festgelegten `F33f`_`[Aufrufkonvention`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Aufrufkonvention]`_`f), auf den Stack gelegt. Dabei erfolgt, falls notwendig, eine `F33f`_`[Konvertierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Konvertierung_(Informatik)]`_`f auf das Format, das vom Unterprogramm benötigt wird.

Bei Aufruf des Unterprogramms wird dann der sogenannte `*Basepointer`* auf die nunmehr erreichte Adresse des Stacks gesetzt. Damit sind die Parameter des Unterprogramms relativ über die Adresse, die im `*Basepointer`* gespeichert ist, erreichbar, auch wenn der Stack für weitere Speicherungen benutzt wird.

>>>Werte oder Referenzen/Zeiger als Parameter

Werden in der tatsächlichen Parameterliste nicht nur `F33f`_`[elementare Datentypen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datentyp]`_`f wie `B100`F9d9int`f`b oder `B100`F9d9float`f`b angegeben, sondern komplette `F33f`_`[Datenstrukturen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenstruktur]`_`f, dann werden im Stack meist nicht die Werte der Datenstruktur selbst, sondern Referenzen (Adressen) auf die Datenstrukturen übergeben. Das hängt allerdings vom Aufruf und der Gestaltung der tatsächlichen Parameterliste ab. In C und C++ ergeben sich folgende Verhältnisse:

`B100`F9d9void function(type* data) // Funktionskopf, formale Parameterliste`f`b

`B100`F9d9…`f`b

`B100`F9d9struct { int a, float b } data; // Datendefinition`f`b

`B100`F9d9function(&data); // Funktionsaufruf, tatsächliche Parameterliste`f`b

In diesem Fall erfolgt beim Aufruf die explizite Angabe der Adresse der Daten, ausgedrückt mit dem `B100`F9d9&`f`b als Referenzierungsoperator. Beim Aufruf ist `B100`F9d9data`f`b ein Zeiger (englisch `*pointer`*) auf die Daten. Allgemein ausgedrückt kann von `*Referenz auf die Daten`* gesprochen werden.

Der Aufruf `B100`F9d9function(data)`f`b ohne den Referenzierungsoperator `B100`F9d9&`f`b führt zu einem Syntaxfehler. In C allerdings nur, wenn der `F33f`_`[Prototyp`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktionsprototyp]`_`f der gerufenen Funktion bekannt ist.

In C++ kann der `F33f`_`[Funktionskopf`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktionskopf]`_`f im gleichen Beispiel mit `B100`F9d9void function(type& data)`f`b geschrieben werden. Dann ist der Aufruf mit `B100`F9d9function(data)`f`b zu gestalten. Der Übersetzer erkennt automatisch aufgrund des in C++ notwendigerweise bekannten Funktionsprototyps, dass die Funktion laut formaler Parameterliste eine Referenz erwartet und kompiliert im Maschinencode das Ablegen der Adresse der Daten auf den Stack. Das entlastet den Programmierer von Denkarbeit, der Aufruf ist einfacher. Allerdings ist beim Aufruf nicht ersichtlich, ob die Daten selbst (`*`F33f`_`[call by value`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Wertparameter]`_`f`*) oder die Adresse der Daten übergeben wird.

In C oder C++ ist es auch möglich, anstelle der meist sinnvollen und gebräuchlichen Referenzübergabe eine Wertübergabe zu programmieren. Das sieht wie folgt aus:

`B100`F9d9void function(type data) // Funktionskopf, formale Parameterliste`f`b

`B100`F9d9…`f`b

`B100`F9d9struct { int a, float b } data; // Datendefinition`f`b

`B100`F9d9function(data); // Funktionsaufruf, tatsächliche Parameterliste`f`b

Beim Aufruf wird der Inhalt der Struktur insgesamt auf den Stack kopiert. Das kann sehr viel sein, wenn die Struktur umfangreich ist. Dadurch kann es zum Absturz des gesamten Ablaufes kommen, wenn die Stackgrenzen überschritten werden und dies in der Laufzeitumgebung nicht erkannt wird. Eine Wertübergabe ist allerdings sinnvoll in folgenden Fällen:

• Übergabe einer kleinen Struktur

• Einkalkulierung der Tatsache, dass der Inhalt der originalen Struktur während der Abarbeitung verändert wird. Die Inhalte der Struktur beim Aufrufer bleiben unverändert, da eine Kopie der Daten angelegt und übergeben wird.

>>>Rückschreiben über referenzierte Daten

In vielen Programmiersprachen ist ein Rückschreiben von Ergebnissen auch über Referenzen, die als Parameter des Unterprogramms übergeben wurden, möglich, beispielsweise in C und C++:

`B100`F9d9void function(Type* data)`f`b

`B100`F9d9{`f`b

`B100`F9d9 data->a = data->b * 2; // Wert in data->a wird veraendert.`f`b

`B100`F9d9}`f`b

Das gilt gleichermaßen für Java. Das Rückschreiben kann ungewollt sein, weil Nebenwirkungen (Nebeneffekte) verhindert werden sollen. Ein Unterprogramm soll die Werte von bestimmten Datenstrukturen nur lesend verarbeiten und wirkungsfrei darauf sein. In C++ (bzw. in C) ist es möglich, zu formulieren:

`B100`F9d9void function(Type const* data)`f`b

`B100`F9d9{`f`b

`B100`F9d9 data->a = data->b * 2; // Hier meldet der Übersetzer einen Syntaxfehler.`f`b

`B100`F9d9}`f`b

Die hier verwendete Schreibweise mit dem Schlüsselwort `B100`F9d9const`f`b soll deutlich machen, dass der gezeigerte (referenzierte) Bereich als konstant zu betrachten ist. Möglicherweise wird `B100`F9d9const Type*`f`b geschrieben, was syntaktisch und semantisch identisch ist. Nur in diesem Fall ist es möglich, einen als konstant deklarierten Speicherbereich überhaupt zu übergeben. Die Konstruktion

`B100`F9d9const struct Type { int a, float b } data = { 5, 27.2 };`f`b

`B100`F9d9function(Type* data) { … } // Funktionsdefinition`f`b

`B100`F9d9function(&data); // Aufruf`f`b

führt in C++ zu einem Syntaxfehler, weil es nicht gestattet ist, als konstant bezeichnete Daten an eine nicht konstante Referenz zu übergeben. In C werden Zeigertypen nicht so genau getestet, so dass dieses Beispiel – abhängig vom verwendeten Übersetzer – in solchen Fällen möglicherweise lediglich eine Warnung auslösen würde.

Allerdings ist es in C und C++ möglich, innerhalb der Funktion den Typ des Zeigers zu wandeln und dann dennoch schreibend auf den Speicherbereich zuzugreifen. Eine solche Programmierung sollte nur in Sonderfällen verwendet werden und sollte nach außen entsprechend dokumentiert werden.

In Java gibt es die Möglichkeit der `B100`F9d9const`f`b-Auszeichnung in einem Referenzparameter zur Unterscheidung des schreibenden oder nicht schreibenden Zugriff auf eine Instanz nicht. Das Konzept sieht stattdessen vor, den Zugriffsschutz über `B100`F9d9private`f`b-Kapselung zu realisieren. Insbesondere können spezifische `F33f`_`[interface`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schnittstelle_(Objektorientierung)]`_`f-Referenzen verwendet werden. Mit dieser Methodik ist es möglich, von außen zu kontrollieren, was eine Subroutine an den übergebenen Daten ändern kann, ohne die Subroutine im Detail zu kennen.

In der `F33f`_`[objektorientierten Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objektorientierte_Programmierung]`_`f in Java und C++ wird die Referenz auf die Klassendaten implizit mit dem `B100`F9d9this`f`b-Zeiger übergeben. Für Klassenmethoden ist also das Schreiben auf die eigenen Daten immer möglich.

>>>Umsetzung auf Maschinenebene

Das Konzept des Stack wurde weiter oben im Abschnitt `*`F33f`_`[Übergabe über den Stack`#perstack]`_`f`* bereits erläutert.

Für Unterprogramme auf Maschinensprachniveau (Assembler) ist es an sich gleichgültig, beziehungsweise liegt es in der Hand des Programmierers, wie er die Parameterübergabe und die Rücksprungadresse verwaltet. Möglich ist auch die Übergabe und Speicherung ausschließlich in Prozessorregistern. Allerdings ist bei der Verwaltung der Rücksprungadresse die Notwendigkeit eines geschachtelten Aufrufs mehrerer (typisch verschiedener) Unterprogramme ineinander zu beachten. Nur bei ganz einfachen Aufgaben ist eine Beschränkung auf wenige oder nur eine Ebene sinnvoll. Es gibt aber tatsächlich bei zugeschnittenen Prozessoren und Aufgabenstellungen auch solche Konzepte.

• Die Rücksprungadresse, das ist die Folgeadresse nach dem Aufruf der Unterprogramme für die Fortsetzung des aufrufenden Programmes, wird auf den Stack gelegt.

• Zuvor werden die Aufrufparameter auf den Stack gelegt.

• Noch zuvor wird ein gegebenenfalls notwendiger Speicherplatz für Rückgabewerte auf dem Stack reserviert, wenn notwendig.

• Der Basepointer wird auf den Stack gelegt.

• Danach wird das Unterprogramm aufgerufen, das heißt, der `F33f`_`[Befehlszähler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Befehlszähler]`_`f wird geändert auf die Startadresse des Unterprogramms.

• Am Beginn des Unterprogramms wird der Basepointer auf den Wert des Stackpointers gesetzt als Adressbezug der Lage der Parameter, des Rücksprunges und der lokalen Variablen.

• Der Stackpointer wird gegebenenfalls weiter dekrementiert, wenn das Unterprogramm lokale Variablen benötigt. Diese liegen auf dem Stack.

• Am Ende des Unterprogramms wird der ursprüngliche Wert des Basepointer vom Stack geholt und damit restauriert.

• Dann wird die Rücksprungadresse vom Stack geholt und der Instruction Pointer damit restauriert.

• Der Stackpointer wird inkrementiert um den Wert, um den vorher dekrementiert wurde.

• Damit wird das aufrufende Programm fortgesetzt.

In Assembler muss man all diese Dinge selbst programmieren. In den Programmiersprachen C++ und C übernimmt das der Übersetzer. In Java erfolgt innerhalb der Speicherbereiche der Virtuellen Maschine das Gleiche, organisiert vom `F33f`_`[Bytecode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bytecode]`_`f (erzeugt vom Java-Übersetzer) und dem Maschinencode in der virtuellen Maschine.

Als Illustration sei hier der erzeugte Assembler-Code (`F33f`_`[80x86`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=X86-Prozessor]`_`f-Assembler) der folgenden einfachen Funktion gezeigt:

`B100`F9d9float parabel(float x)`f`b

`B100`F9d9{`f`b

`B100`F9d9 return x * x;`f`b

`B100`F9d9}`f`b

Als `F33f`_`[Compiler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`f wurde `F33f`_`[Microsoft Visual Studio`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_Visual_Studio]`_`f 6 auf einem PC verwendet. Der Assemblercode ist in dieser `F33f`_`[IDE`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Integrierte_Entwicklungsumgebung]`_`f sichtbar, beispielsweise beim Debuggen in Maschinenebene, aber auch wenn mit entsprechenden Compileroptionen Listingfiles erzeugt werden.

Maschinencode für den Aufruf: `B100`F9d9float y = parabel(2.0F);`f`b

`B100`F9d9 push 40000000h ; Der Wert 2.0 wird in den Stack gelegt.`f`b

`B100`F9d9 call parabel ; Aufruf des Unterprogramms;`f`b

`B100`F9d9 ; call legt den Instructionpointer in den Stack`f`b

`B100`F9d9 add esp, 4 ; Addieren von 4, das ist Byteanzahl des Parameters`f`b

`B100`F9d9 fst dword ptr [ebp - 4] ; Abspeichern des Ergebnisses in y`f`b

Maschinencode des Unterprogramms:

`B100`F9d9parabel:`f`b

`B100`F9d9 push ebp ; Der Basepointer wird im Stack gespeichert.`f`b

`B100`F9d9 mov ebp, esp ; Der Basepointer wird mit dem Wert des Stackpointer geladen.`f`b

`B100`F9d9 sub esp, 40h ; 64 Byte Stack werden reserviert.`f`b

`B100`F9d9 push ebx ; CPU-Register, die hier verwendet = geändert werden,`f`b

`B100`F9d9 push esi ; werden im Stack zwischengespeichert.`f`b

`B100`F9d9 push edi`f`b

`B100`F9d9 fld dword ptr [ebp + 8] ; Der Wert des Parameters x wird relativ zum Basepointer geladen`f`b

`B100`F9d9 fmul dword ptr [ebp + 8] ; und in der floating-point-unit mit selbigem multipliziert.`f`b

`B100`F9d9`f`b

`B100`F9d9 pop edi ; Register werden restauriert.`f`b

`B100`F9d9 pop esi`f`b

`B100`F9d9 pop ebx`f`b

`B100`F9d9 mov esp, ebp ; Der Stackpointer wird genau auf den Stand wie beim Aufruf`f`b

`B100`F9d9 ; des Unterprogramms gebracht.`f`b

`B100`F9d9 pop ebp ; Der Basepointer wird aus dem Stack restauriert.`f`b

`B100`F9d9 ret ; Der Instruction pointer wird aus dem Stack restauriert`f`b

`B100`F9d9 ; und damit wird nach dem call (oben) fortgesetzt.`f`b

Folgendes Beispiel zeigt einen handgeschriebenen Assemblercode für den Signalprozessor ADSP-216x von Analog Devices für folgende aus C zu rufende Funktion:

`B100`F9d9float set_floatExtend(_floatExtend* dst, float nVal);`f`b

Dabei handelt es sich um eine Funktion, die einen in `B100`F9d9nVal`f`b stehenden Wert auf der Adresse `B100`F9d9dst`f`b speichern soll. Das Besondere hierbei ist, dass der Fließkommawert 40 Bit umfasst und auf zwei 32-bittige Speicheradressen aufgeteilt werden muss.

`B100`F9d9 .GLOBAL _set_floatExtend;  ; Sprunglabel global sichtbar`f`b

`B100`F9d9 _set_floatExtend: ; Sprunglabel angeben, das ist der Name des Unterprogramms,`f`b

`B100`F9d9 ; aus C ohne Unterstrich anzugeben.`f`b

`B100`F9d9 I4 = R4;  ; Im Register R4 wird der erste Parameter _floatExtend* dst übergeben.`f`b

`B100`F9d9 ; Da es eine Adresse ist, wird diese in das Adressregister I4 umgeladen.`f`b

`B100`F9d9 PX = F8;  ; Der zweite Parameter float nVal wird aus F8 in das Register PX geladen.`f`b

`B100`F9d9 dm(0,I4) = PX1;  ; Ein Teil des Inhaltes von PX, in PX1 sichtbar, wird auf`f`b

`B100`F9d9 ; der Adresse gespeichert, die von I4 gezeigert wird.`f`b

`B100`F9d9 dm(1,I4) = PX2;  ; Speicherung des zweiten Teils auf der Folgeadresse`f`b

`B100`F9d9 ! FUNCTION EPILOGUE: ; Standard-Abschluss des Unterprogramms:`f`b

`B100`F9d9 i12 = dm(-1,i6);  ; Das Adressregister i12 wird aus einer Adresse relativ zum Basepointer`f`b

`B100`F9d9 ; (hier i6) geladen. Das ist die Rücksprungadresse.`f`b

`B100`F9d9 jump (m14,i12) (DB) ; Das ist der Rücksprung unter Nutzung des Registers i12.`f`b

`B100`F9d9 F0 = F8;  ; nach dem Rücksprung werden die noch im cashe stehenden Befehl verarbeitet,`f`b

`B100`F9d9 ; hier wird der Wert in F8 nach dem Register R0 geladen, für return.`f`b

`B100`F9d9 RFRAME;  ; dieser Befehl korrigiert den Basepointer i6 und Stackpointer i7.`f`b

>>Definition und technische Anwendung von Unterprogramm-Parametern

>>>Formale Parameter

Die formalen Parameter eines Unterprogramms werden bei dessen Deklaration oder Definition normalerweise hinter dem Namen des Unterprogramms angegeben. Mit diesen kann im Unterprogramm beispielsweise gerechnet werden, ohne dass konkrete Werte bekannt sind. Bei einer Deklaration sind oft nur die `F33f`_`[Datentypen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datentyp]`_`f der formalen Parameter anzugeben. Die verwendeten Parameter müssen immer `F33f`_`[zuweisungskompatibel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zuweisungskompatibilität]`_`f zu diesen formalen Definitionen sein.

Beispiel: Unterprogrammdeklaration in den Programmiersprachen PASCAL und Delphi mit `*x`* und `*y`* als formalen Parametern:

`B100`F9d9 FUNCTION Radius(x, y : REAL) : REAL;`f`b

`B100`F9d9 BEGIN`f`b

`B100`F9d9 Radius := SQRT((x * x) + (y * y))`f`b

`B100`F9d9 END;`f`b

Die formalen Parameter, hier `B100`F9d9x`f`b und `B100`F9d9y`f`b, sind Platzhalter für die bei jeder Verwendung zu übergebenden Argumente oder tatsächlichen Parameter.

>>>Tatsächliche Parameter oder Argumente

Zur Verwendung des Unterprogramms wird dieses mit die Ausführung beeinflussenden tatsächlichen Parametern (Argumenten) aufgerufen; diese definieren für diese Ausführung den anfänglichen konkreten Wert der abstrakten formalen Parameter. Zur besseren Unterscheidung von formalen Parametern wurde für tatsächliche Parameter auch die Bezeichnung `*Argument`* etabliert, besonders in Beschreibungen von Programmiersprachen.`:cite-ref-1[`F5bf`_`[1`#cite-note-1]`_`f]`:cite-ref-2[`F5bf`_`[2`#cite-note-2]`_`f] Im Deutschen findet man auch die Bezeichnung `*aktueller Parameter`*, durch die falsche Übersetzung des englischen Ausdrucks `*actual parameter`* (tatsächlicher Parameter). Die Art der Übergabe ist von Programmiersprache zu Programmiersprache verschieden. Die Sprache `F33f`_`[Fortran`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fortran]`_`f verwendet beim Übersetzen festgelegte Speicheradressen für jedes Unterprogramm. Sprachen wie `F33f`_`[Pascal`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Pascal_(Programmiersprache)]`_`f oder `F33f`_`[C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f verwenden den `F33f`_`[Stack`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stapelspeicher]`_`f oder Prozessorregister zur Parameterübergabe.

Beispiel: Aufruf des Unterprogramms mit verschiedenen tatsächlichen Parametern:

`B100`F9d9 r1 := Radius(x1, y1); -- tatsächliche Parameter x := x1 und y := y1`f`b

`B100`F9d9 Durchmesser := 2 * Radius(13, -2); -- tatsächliche Parameter x := 13 und y := -2`f`b

Kurz: (formale) Parameter stellen benannten Speicherplatz zur Verfügung, ähnlich algebraischen Variablen, Argumente oder tatsächliche Parameter sind konkrete Werte (oder Datenobjekte), die dort gespeichert und entsprechend verwendet werden.

>>>Type-Hinting

Werden die `F33f`_`[Datentypen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datentyp]`_`f der formalen Parameter vorgegeben, wie im obigen Beispiel, spricht man von `!Type-Hinting`!. Type-Hinting ist in vielen Programmiersprachen (`F33f`_`[C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f, `F33f`_`[C++`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C++]`_`f, `F33f`_`[Java`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_(Programmiersprache)]`_`f und einige mehr) Pflicht (das Auslassen führt zu einem `F33f`_`[Syntaxfehler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Syntaxfehler]`_`f), während `F33f`_`[Skriptsprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Skriptsprache]`_`f häufig keine Möglichkeit bieten Type-Hinting zu verwenden.

• Ein Beispiel aus `F33f`_`[C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f bzw. `F33f`_`[C++`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C++]`_`f:

`B100`F9d9 float radius (float x, float y);`f`b

• Ein Beispiel aus `F33f`_`[PHP`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=PHP]`_`f ohne Type-Hinting:

`B100`F9d9 function radius($x, $y);`f`b

• Ein Beispiel aus `F33f`_`[PHP`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=PHP]`_`f mit Type-Hinting:

`B100`F9d9 /* Der erste Parameter muss vom Typ der Klasse PDO sein, andernfalls wird ein Fehler erzeugt */`f`b

`B100`F9d9 function getData(PDO $db, $y);`f`b

>>>Ersetzen der formalen durch tatsächliche Parameter

Es gibt unterschiedliche Methoden, wie die formalen Parameter während der Parameterübergabe durch die tatsächlichen Parameter ersetzt werden:

1. Bei `F33f`_`[Wertparametern`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Wertparameter]`_`f (`*call by value`*) wird der Wert eines Ausdrucks berechnet und gegebenenfalls eine `*Kopie`* des Ergebnisses erzeugt. Dieses wird an Stelle des formalen Parameters verwendet. Die tatsächlichen Parameter können beliebige Ausdrücke wie 2 ∗ ∗ x + 1 {\\displaystyle 2*x+1} oder s i n ( x ) {\\displaystyle sin(x)} sein. Etwaige Änderungen der Parameter im Unterprogramm werden nur in der `*Kopie`* durchgeführt und gehen bei Abschluss des Unterprogramms verloren. Große Datenstrukturen wie Felder werden bei der Übergabe kopiert, was unerwünscht sein kann.

2. `F33f`_`[Referenzparameter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Referenzparameter]`_`f (`*call by reference`*) übergeben eine Referenz (normalerweise die `F33f`_`[Speicheradresse`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Speicheradresse]`_`f) des tatsächlichen Parameters. Dies ist in der Regel sehr schnell. Änderungen bleiben auch nach Abschluss des Unterprogramms wirksam. Tatsächliche Parameter können nur Ausdrücke sein, deren Adresse berechnet werden kann, also z. B. keine Konstanten.

3. `F33f`_`[Namensparameter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Namensparameter]`_`f (`*call by name`*) setzen den Namen des tatsächlichen Parameters an Stelle des formalen Parameters ein. Dies kann auch mehrfach geschehen. Zusammen mit dem tatsächlichen Parameter wird eine Umgebung übergeben, welche die Bindungen der freien Variablen, welche im tatsächlichen Parameter vorkommen, angibt. Der Unterschied zu Wertparametern ist, dass der Ausdruck jedes Mal berechnet wird, wenn der Parameter in der aufgerufenen Funktion benutzt wird.

In einem Makro wird der formale Parameter textuell durch den tatsächlichen Parameter ersetzt. Der Unterschied zu `F33f`_`[Namensparametern`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Namensparameter]`_`f besteht darin, dass Namenskonflikte in Kauf genommen werden. Kommt in einem tatsächlichen Parameter eine Variable vor, welche den gleichen Namen wie eine lokale Variable besitzt, so wird bei der Makroexpansion die lokale Variable verwendet.

1. `F33f`_`[Wertergebnisparameter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Wertergebnisparameter]`_`f (`*call by value/return`* oder `*call by value and result`*) erzeugen wie Wertparameter beim Aufruf zunächst eine Kopie des tatsächlichen Parameters. Bei Unterprogrammende wird der Inhalt des Parameters jedoch zurückgeschrieben. Dieser Parameterübergabemechanismus kann bei nebenläufigen Programmen eine andere Wirkung als die Verwendung von Referenzparametern haben, da während der Ausführungszeit des Unterprogramms ein anderer Thread auf die Variable in der aufrufenden Prozedur zugreifen kann.

2. Ergebnisparameter (`*call by result`*) erstellen eine lokal gültige, nicht initialisierte Variable als Parameter. Dieser Variable wird während der Abarbeitung des Unterprogramms ein Wert zugewiesen und bei Unterprogrammende in die Speicherposition des Aufrufparameters kopiert, sodass dieser überschrieben wird.

3. Call-by-Need ist eine Variante von `F33f`_`[Namensparametern`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Namensparameter]`_`f, bei der jeder übergebene tatsächliche Parameter maximal einmal ausgewertet wird. Wird ein tatsächlicher Parameter ausgewertet, so werden alle Vorkommen des formalen Parameters durch den erhaltenen Wert ersetzt. In `F33f`_`[Haskell`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Haskell_(Programmiersprache)]`_`f ist call-by-need Teil der Lazy Evaluation.

Moderne, prozedurale Programmiersprachen unterstützen in der Regel Wertparameter und Referenzparameter, manchmal auch Wertergebnisparameter.

>>>Beispiel für verschiedene Parameterübergaben

`B100`F9d9 proc test(x,y)`f`b

`B100`F9d9 {`f`b

`B100`F9d9 y = y + 1;`f`b

`B100`F9d9 x = 10 * x;`f`b

`B100`F9d9 }`f`b

`B100`F9d9`f`b

`B100`F9d9 a = 5;`f`b

`B100`F9d9 b = 4;`f`b

`B100`F9d9 test(a, b);`f`b

`B100`F9d9 print(a, b);`f`b

`B100`F9d9 test(b, b);`f`b

`B100`F9d9 print(b);`f`b

`!Ausgabe bei Wertparametern (`*call by value`*)`!

`B100`F9d9 5 4`f`b

`B100`F9d9 4`f`b

Erklärung: Es wird durch die Aufrufe von `B100`F9d9test`f`b keine Veränderung an den Variablen a und b durchgeführt, sodass die Variablen jeweils nach Beendung des Unterprogramms ihren ursprünglichen Wert beibehalten.

`!Ausgabe bei Referenzparametern (`*call by reference`*)`!

`B100`F9d9 50 5`f`b

`B100`F9d9 60`f`b

Erklärung: Beim Aufruf von `B100`F9d9test`f`b in Zeile 9 erhält x die Referenz zu a und y die Referenz zu b. Bei der Abarbeitung wird y zunächst um 1 erhöht. Da b und y auf die gleiche Adresse verweisen, hat b also nun den Wert 5. In der nächsten Zeile wird x mit 10 multipliziert, somit hat a nun den Wert 50.

In der zweiten Abarbeitung von `B100`F9d9test`f`b, aufgerufen in Zeile 11, verweisen sowohl x, als auch y auf b, da b für beide Parameter angegeben wurde. Daher werden alle Veränderungen, die in `B100`F9d9test`f`b an x und y ausgeführt werden, im gleichen Speicherbereich ausgeführt. y hatte vor diesem Aufruf den Wert 5, wird in Zeile 3 um 1 erhöht und anschließend wird in Zeile 4 dieser Wert mit 10 multipliziert; also steht an der Speicherstelle nun der Wert 60. Zurück im Hauptprogramm weist b dann auf die Adresse, an der die soeben berechnete 60 steht, also wird 60 in Zeile 12 für b ausgegeben.

`!Ausgabe bei Wertergebnisparametern (`*call by value and result`*)`!

`B100`F9d9 50 5`f`b

`B100`F9d9 6 ''oder'' 50`f`b

Erklärung: Beim zweiten Aufruf von `B100`F9d9test`f`b werden zwei Kopien von b erstellt, auf die x und y innerhalb von `B100`F9d9test`f`b zeigen. x hat bei Beendung des Unterprogramms den Wert 50, y hat den Wert 6. Je nachdem, welcher Wert zuerst in das ursprüngliche b zurück gespeichert wird, kann das Ergebnis variieren.

>>Befehlszeilenparameter

Zudem besteht bei vielen gängigen `F33f`_`[Programmen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerprogramm]`_`f für alle gängigen `F33f`_`[Betriebssysteme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Betriebssystem]`_`f die Möglichkeit, Parameter in der `F33f`_`[Befehlszeile`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Befehlszeile]`_`f zu übergeben, die dann beim Aufrufen bearbeitet werden.

`!Beispiel: Fiktiver Programmaufruf über die Befehlszeile unter `F33f`_`[Windows`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Windows]`_`f`!

`B100`F9d9 programm.exe -parameter -weiterer -xyz=(a|b) /usw`f`b

Hiermit würde programm.exe mit den Parametern „parameter“, „weiterer“, „xyz=(a|b)“ und „usw“ aufgerufen werden. Parameter werden also mit oder ohne Wertangabe verwendet, wobei die Wertangabe dem Namen mit `F33f`_`[Leerraum`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Leerraum]`_`f, mit Sonderzeichen wie „=“ oder gar nicht abgegrenzt angehängt wird. Je nachdem, welches Programm verwendet wird, stehen verschiedene Parameter zur Verfügung; je nach Programm haben gleich benannte Parameter im Allgemeinen unterschiedliche Auswirkungen. Auch die formalen Regeln zur Angabe sind vom Programm abhängig; dass, wie im Beispiel, mehrere unterschiedliche Trennzeichen verwendet werden, ist zwar unüblich und dient nur der Demonstration, aber viele Programme bieten durchaus flexible Möglichkeiten.

Unter `F33f`_`[Unix`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Unix]`_`f-artigen Systemen werden Parameter traditionell mit einzelnen Buchstaben angegeben und mit „-“ eingeleitet, wenn es sich um `*Optionen`* oder `*Schalter`* handelt, die aus einer für das jeweilige Programm feststehenden Menge ausgewählt werden können; dagegen werden Parameter nicht besonders eingeleitet, wenn es sich um Dateinamen und ähnliche freie Angaben handelt. Die Abgrenzung voneinander geschieht erforderlichenfalls durch Leerraum. Beispiel: „ls -l -t /usr/bin /usr/local/bin“ oder gleichbedeutend „ls -lt /usr/bin /usr/local/bin“. Bei Programmen, die sowohl einbuchstabige als auch mehrbuchstabige Optionen annehmen, sind Letztere mit „--“ einzuleiten.

Unter DOS (in Tradition von `F33f`_`[OpenVMS`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=OpenVMS]`_`f) wird traditionell „/“ an Stelle des „-“ verwendet und Werte von Parameternamen mit „=“ abgetrennt. Unter Windows sind beide Stile anzutreffen.

Allgemein kann man sagen, dass versierte Benutzer bei Verwendung von Befehlszeilenparametern oft schneller zu Ergebnissen kommen als durch andere Bedienmöglichkeiten, wie beispielsweise Dialogfenster in einer `F33f`_`[GUI`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Grafische_Benutzeroberfläche]`_`f. So ist es mit `F33f`_`[IrfanView`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=IrfanView]`_`f zum Beispiel ein Leichtes, mittels dreier Parameter beliebig viele Bilder zu laden, zu konvertieren und in einem anderen `F33f`_`[Format`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dateiformat]`_`f zu speichern.

>>Siehe auch

• Qualitätskriterien für Software nach `F33f`_`[ISO/IEC 9126`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ISO/IEC_9126]`_`f

• Ähnliche Bedeutungen von `F33f`_`[Parameter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Parameter]`_`f

>>Einzelnachweise

`:cite-note-1`!1.`! `F0af`_`[↑`#cite-ref-1]`_`f British Standards Institute (Hrsg.): The C Standard – Incorporating TC1 – BS ISO/IEC 9899:1999. John Wiley & Sons, 2003, ISBN 0-470-84573-2, 3.1.

`:cite-note-2`!2.`! `F0af`_`[↑`#cite-ref-2]`_`f `*Working Draft, Standard for Programming Language C++.`* (PDF; 4,6 MB) Abgerufen am 26. September 2010 (englisch, Kap. 1.3.1).

`c`F0af`_`[↑ Back to top`#top]`_`f`a